home *** CD-ROM | disk | FTP | other *** search
/ Internet Info 1994 March / Internet Info CD-ROM (Walnut Creek) (March 1994).iso / networking / terms / kermit / b / ck9fio.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-06-30  |  47.5 KB  |  1,600 lines
  1. char *ckzv = "OS-9 file support, 5A(08) 01 Dec 92";
  2. char *ckzsys = " OS-9/68000";
  3.  
  4. /* c k 9 F I O  --  Kermit file system support for OS-9/68k systems */
  5.  
  6. /*
  7.  Author: Peter Scholz,
  8.  Ruhr University Bochum, Department for Analytical Chemistry,
  9.  Federal Republic of Germany,   February 1987
  10.  
  11.  04/30/87 Robert Larson         Cleanup, merge with standard C-kermit
  12.  04/07/89 Robert Larson         Update for ckermit 4f(77)
  13.  07/16/89 Robert Larson         4f(85)
  14.  Edition: 5A(01)
  15.  06/21/91 Chris  Hemsing        general adaption to 5A(171)
  16.                                 miscellaneous bug fixes, utilization of
  17.                                 initial file size.
  18.  07/25/91 Chris  Hemsing        minor bug fixes, changes for gnu (ansi) C
  19.  01/14/92 Chris  Hemsing        uct/localtime  bug fix
  20.  05/26/92 Chris  Hemsing        zltor and zrtol bug fix
  21.  Edition: 5A(05)
  22.  06/30/92 Chris  Hemsing        pipeopen stderr bug fix,dir shows filesize
  23.  Edition: 5A(06)
  24.  07/09/92 Chris  Hemsing        removed all chaining which would save a
  25.                                 process but f$chain does not look in PATH
  26.  Edition: 5A(07)
  27.  07/10/92 Chris  Hemsing        remove whole process tree of a lower fork
  28.  Edition: 5A(08)
  29.  12/01/92 Chris  Hemsing        zgtdir bugs repaired: upmost dir not closed
  30.                                 closedir of non-open dir could be called
  31.   adapted from Unix C-Kermit
  32.   Author: Frank da Cruz (SY.FDC@CU20B),
  33.   Columbia University Center for Computing Activities, January 1985.
  34.   Copyright (C) 1985, 1992, Trustees of Columbia University in the City of New
  35.   York.  Permission is granted to any individual or institution to use this
  36.   software as long as it is not sold for profit.  This copyright notice must be
  37.   retained.  This software may not be included in commercial products without
  38.   written permission of Columbia University.
  39. */
  40. /* Includes */
  41.  
  42. #include "ckcdeb.h"             /* Typedefs, debug formats, etc */
  43. #include "ckcker.h"             /* Kermit definitions */
  44. #include <dir.h>                /* Directory structure */
  45. #include <direct.h>
  46. #include <modes.h>
  47. #include <procid.h>
  48. #include <signal.h>
  49. #include <strings.h>
  50. #include <time.h>
  51.  
  52. /* Definitions of some system commands */
  53.  
  54. char *DIRCMD = "dir -e ";          /* For directory listing with filename*/
  55. char *DIRCM2 = "dir -e ";           /* For directory listing without filename*/
  56. char *DELCMD = "del ";          /* For file deletion */
  57. char *TYPCMD = "list ";         /* For typing a file */
  58. char *PWDCMD = "pd ";           /* For saying where I am */
  59.  
  60. char *SPACMD = "free ";
  61. char *SPACM2 = "free ";         /* For space in specified directory */
  62.  
  63. char *WHOCMD = "procs -e ";        /* we have no who yet*/
  64.  
  65. /*
  66.   Functions (n is one of the predefined file numbers from ckermi.h):
  67.  
  68.    zopeni(n,name)   -- Opens an existing file for input.
  69.    zopeno(n,name,attr,fcb) -- Opens a new file for output.
  70.    zclose(n)        -- Closes a file.
  71.    zchin(n,&c)      -- Gets the next character from an input file.
  72.    zsout(n,s)       -- Write a null-terminated string to output file,buffered.
  73.    zsoutl(n,s)      -- Like zsout, but appends a line terminator.
  74.    zsoutx(n,s,x)    -- Write x characters to output file, unbuffered.
  75.    zchout(n,c)      -- Add a character to an output file, unbuffered.
  76.    zchki(name)      -- Check if named file exists and is readable,return size.
  77.    zchko(name)      -- Check if named file can be created.
  78.    zchkspa(name,n)  -- Check if n bytes available to create new file, name.
  79.    znewn(name,s)    -- Make a new unique file name based on the given name.
  80.    zdelet(name)     -- Delete the named file.
  81.    zxpand(string)   -- Expands the given wildcard string into a list of files.
  82.    znext(string)    -- Returns the next file from the list in "string".
  83.    zxcmd(cmd)       -- Execute the command in a lower fork.
  84.    zclosf()         -- Close input file associated with zxcmd()'s lower fork.
  85.    zrtol(n1,n2)     -- Convert remote filename into local form.
  86.    zltor(n1,n2)     -- Convert local filename into remote form.
  87.    zchdir(dirnam)   -- Change working directory.
  88.    zhome()          -- Return pointer to home directory name string.
  89.    zkself()         -- Kill self, log out own job.
  90.    zsattr(struc zattr *) -- Return attributes for file which is being sent.
  91.  */
  92.  
  93.  
  94. /* Some systems define these in include files, others don't... */
  95.  
  96. #define MAXWLD 500
  97.  
  98. /* Declarations */
  99. #define MAXPATH 256                     /* not really an OS-9 restriction */
  100.  
  101.  
  102. FILE *fp[ZNFILS] = {    /* File pointers */
  103.     NULL, NULL, NULL, NULL, NULL, NULL, NULL };
  104.  
  105. /* (PWP) external def. of things used in buffered file input and output */
  106. #ifdef DYNAMIC
  107. extern CHAR *zinbuffer, *zoutbuffer;
  108. #else
  109. extern CHAR zinbuffer[], zoutbuffer[];
  110. #endif /* DYNAMIC */
  111. extern CHAR *zinptr, *zoutptr;
  112. extern int zincnt, zoutcnt;
  113.  
  114. struct fildes cur_in_fd;              /* current input filedesc */
  115. static int cur_in_size = -1;          /* current input file length */
  116.  
  117. static int pipe_pid;                            /* pid of child fork */
  118. static int fcount;                      /* Number of files in wild group */
  119. char *malloc(), *getenv(), *strcpy();   /* System functions */
  120. extern errno;                           /* System error code */
  121.  
  122. char *mtchs[MAXWLD],             /* Matches found for filename */
  123.      **mtchptr;                         /* Pointer to current match */
  124.  
  125. /*  Z K S E L F  --  Kill Self: log out own job, if possible.  */
  126.  
  127. zkself() {                              /* For "bye" */
  128. procid pbuf;
  129.   _get_process_desc(getpid(),sizeof(pbuf),&pbuf);
  130.   if (kill((int)pbuf._pid,SIGKILL)==0)
  131.     doexit(GOOD_EXIT,-1);/*kill parent process*/
  132.   else
  133.     doexit(errno,-1);
  134. }
  135.  
  136. char *zgtdir() {
  137.     /* I'm sure this can be done better... */
  138.     static char cwd[MAXPATH];
  139.     char backpath[MAXPATH];
  140.     char *bpp = backpath, *path = cwd;
  141.     DIR *dirp;
  142.     struct direct *dp;
  143.     long inode, inode2;
  144.     char dots[MAXPATH];
  145.  
  146.     if((dirp = opendir(".")) == NULL) return NULL;
  147.     if((readdir(dirp) == NULL) || (dp = readdir(dirp)) == NULL) {
  148.         closedir(dirp);
  149.         return (char *)NULL;
  150.     }
  151.     inode = dp->d_addr;
  152.     *path++ = '/';
  153.     _gs_devn(dirp->dd_fd, path);
  154.     path += strlen(path);
  155.     closedir(dirp);
  156.     strcpy(dots, "..");
  157.     for(;;) {
  158.         if((dirp = opendir(dots)) == NULL) return NULL;
  159.         if((readdir(dirp) == NULL) || (dp = readdir(dirp)) == NULL) {
  160.             closedir(dirp);
  161.             return (char *)NULL;
  162.         }
  163.         inode2 = dp->d_addr;
  164.         if(inode == inode2) break; /* .. and . are same, we are done */
  165.         do {
  166.             if((dp = readdir(dirp)) == NULL) {
  167.                 closedir(dirp);
  168.                 return (char *)NULL;
  169.             }
  170.         } while(dp->d_addr != inode);
  171.         *bpp++ = '/';
  172.         strcpy(bpp, dp->d_name);
  173.         bpp += strlen(bpp);
  174.         closedir(dirp);
  175.         inode = inode2;
  176.         strcat(dots, "/..");
  177.     }
  178.     closedir(dirp); /* close upmost directory */
  179.     while(bpp > backpath) {
  180.         *bpp = '\0';
  181.         while(*--bpp != '/') {}
  182.         strcpy(path, bpp);
  183.         path += strlen(path);
  184.     }
  185.     return cwd;
  186. }
  187.  
  188.  
  189. /*  Z O P E N I  --  Open an existing file for input. */
  190.  
  191. zopeni(n,name) int n; char *name; {
  192.     debug(F111," zopeni",name,n);
  193.     debug(F101,"  fp","",(int) fp[n]);
  194.     if (chkfn(n) != 0) return(0);
  195.     zincnt = 0;                         /* Reset input buffer */
  196.     if (n == ZSYSFN) {                  /* Input from a system function? */
  197. /*** Note, this function should not be called with ZSYSFN ***/
  198. /*** Always call zxcmd() directly, and give it the real file number ***/
  199. /*** you want to use.  ***/
  200.         debug(F110,"zopeni called with ZSYSFN, failing!",name,0);
  201.                 return(0);                      /* fail. */
  202.     }
  203.     if (n == ZSTDIO) {   /* Standard input? */
  204.         if (isatty(0)) {
  205.             ermsg("Terminal input not allowed");
  206.             debug(F110,"zopeni: attempts input from unredirected stdin","",0);
  207.             return(0);
  208.         }
  209.         fp[ZIFILE] = stdin;
  210.         return(1);
  211.     }
  212.     fp[n] = fopen(name,"r");            /* Real file. */
  213.     debug(F111," zopeni", name, (int) fp[n]);
  214.     if (fp[n] == NULL) perror("zopeni");
  215.     return((fp[n] != NULL) ? 1 : 0);
  216. }
  217.  
  218. /*  Z O P E N O  --  Open a new file for output.  */
  219.  
  220. zopeno(n,name,zz,fcb)
  221. /* zopeno */  int n; char *name; struct zattr *zz; struct filinfo *fcb; {
  222.  
  223. /* As of Version 5A, the attribute structure and the file information */
  224. /* structure are included in the arglist. */
  225.  
  226.     char *p;
  227.     int pn;
  228.     debug(F111,"zopeno",name,n);
  229.     if (chkfn(n) != 0) return(0);
  230.     zoutcnt = 0;
  231.     zoutptr = zoutbuffer;
  232.     if (fcb)
  233.     {
  234.           debug(F101,"zopeno fcb disp","",fcb->dsp);
  235.           debug(F101,"zopeno fcb type","",fcb->typ);
  236.           debug(F101,"zopeno fcb char","",fcb->cs);
  237.     }
  238.     else debug(F100,"zopeno fcb is NULL","",0);
  239.     if ((n == ZCTERM) || (n == ZSTDIO))
  240.     {   /* Terminal or standard output */
  241.           fp[ZOFILE] = stdout;
  242.           debug(F101," fp[]=stdout", "", (int) fp[n]);
  243.           return(1);
  244.     }
  245.  
  246. /* A real file.  Open it in desired mode (create or append). */
  247.     p = "w";                            /* Assume write/create mode */
  248.     if (fcb) {                          /* If called with an FCB... */
  249.         if (fcb->dsp == XYFZ_A)         /* Does it say Append? */
  250.           p = "a";                      /* Yes. */
  251.     }
  252.     if (access(name,0) == 0) /* does file exist ? */
  253.     {
  254.       if ((fp[n] = fopen(name,p)) == NULL)      /* Simply open the file */
  255.       {
  256.         perror("zopeno can't open");
  257.         return(0);
  258.       }
  259.       debug(F111, " exist:fp[n]",p, (int) fp[n]);
  260.     }
  261.     else /* file does not exist, we can open with initial size */
  262.          /* this is very important for long files not to be too fragmented */
  263.          /* so that after a long transmission OS-9 may finish saying that */
  264.          /* the segment allocation table is full */
  265.     {
  266.       if ((zz) && ((zz->length > 0) || (zz->lengthk > 0)))
  267.                                     /* length estimate available ? */
  268.       {
  269.         if ((pn = create(name,S_IREAD+S_IWRITE+S_ISIZE,
  270.              S_IREAD+S_IWRITE,
  271.              (zz->length > 0) ? zz->length : (zz->lengthk*1024L))) != -1)
  272.         {
  273.           debug(F111, " create with init. size:",p,
  274.                 (zz->length > 0) ? zz->length : (zz->lengthk*1024L));
  275.           if ((fp[n] = fdopen(pn,"w")) == NULL) /* get filepntr for pn */
  276.           {
  277.             perror("zopeno can't open");
  278.             return(0);
  279.           }
  280.           debug(F111, " create with init. size:fp[n]",p, (int) fp[n]);
  281.         }
  282.         else
  283.         {
  284.           perror("zopeno can't open");
  285.           return(0);
  286.         }
  287.       }
  288.       else /* no length available */
  289.       {
  290.         if ((fp[n] = fopen(name,p)) == NULL)    /* Simply open the file */
  291.         {
  292.           perror("zopeno can't open");
  293.           return(0);
  294.         }
  295.         debug(F111, " create without init size fp[n]",p, (int) fp[n]);
  296.       }
  297.     }
  298.     if((zz) && (zz->systemid.val[0] == 'U') && ( zz->systemid.val[1] == 'D'))
  299.     {
  300.       debug(F101, "zopeno:file originated from OS-9","",zz->lprotect.val[0]);
  301.       if (zz->lprotect.len != 0)
  302.       {
  303.         if (_ss_attr(fp[n]->_fd,(zz->lprotect.val[0]&0x7f)|S_IWRITE) == -1)
  304.         {
  305.           debug(F101, "zopeno:can't set file attr","",errno);
  306.           return(0);
  307.         }
  308.       }
  309.     }
  310.     if (n == ZDFILE) setbuf(fp[n],(char *)NULL); /* Debug file unbuffered */
  311.     return(1);
  312. }
  313.  
  314. /*  Z C L O S E  --  Close the given file.  */
  315. /*  Returns 0 if arg out of range, 1 if successful, -1 if close failed.  */
  316.  
  317. zclose(n) int n; {
  318.     int x, x2;
  319.     if (chkfn(n) < 1) return(0);        /* Check range of n */
  320.  
  321.     if ((n == ZOFILE) && (zoutcnt > 0)) /* (PWP) output leftovers */
  322.       x2 = zoutdump();
  323.     else
  324.       x2 = 0;
  325.  
  326.     x = 0;                              /* Initialize return code */
  327.     if (fp[ZSYSFN]) {                   /* If file is really pipe */
  328.         x = zclosf(n);                  /* do it specially */
  329.     } else {
  330.         if ((fp[n] != stdout) && (fp[n] != stdin)) x = fclose(fp[n]);
  331.             fp[n] = NULL;
  332.     }
  333.     if (x == EOF)                       /* if we got a close error */
  334.                 return (-1);
  335.     else if (x2 < 0)            /* or an error flushing the last buffer */
  336.                 return (-1);            /* then return an error */
  337.     else
  338.                 return (1);
  339. }
  340.  
  341. /*  Z C H I N  --  Get a character from the input file.  */
  342.  
  343. /*  Returns -1 if EOF, 0 otherwise with character returned in argument  */
  344.  
  345. zchin(n,c) int n; int *c; {
  346.     int a;
  347.  
  348.     /* (PWP) Just in case this gets called when it shoudn't */
  349.     if (n == ZIFILE)
  350.         return (zminchar());
  351.  
  352.     /* if (chkfn(n) < 1) return(-1); */
  353.     a = getc(fp[n]);
  354.     if (a == EOF) return(-1);
  355.     *c = a & 0377;
  356.     return(0);
  357. }
  358.  
  359. /*  Z I N F I L L  --  Get a character from the input file.
  360.  * (PWP) (re)fill the buffered input buffer with data.  All file input
  361.  * should go through this routine, usually by calling the zminchar()
  362.  * macro (in ckcker.h).
  363.  */
  364.  
  365. zinfill() {
  366.     zincnt = fread((char *)zinbuffer, sizeof (char), INBUFSIZE, fp[ZIFILE]);
  367.     if (zincnt == 0) return (-1);       /* end of file */
  368.     zinptr = zinbuffer;    /* set pointer to beginning, (== &zinbuffer[0]) */
  369.     zincnt--;                           /* one less char in buffer */
  370.     return((int)(*zinptr++) & 0377);    /* because we return the first */
  371. }
  372.  
  373. /*  Z S O U T  --  Write a string to the given file, buffered.  */
  374.  
  375. zsout(n,s) int n; char *s; {
  376.     if (chkfn(n) < 1) return(-1);
  377.     fputs(s,fp[n]);
  378.     return(0);
  379. }
  380.  
  381. /*  Z S O U T L  --  Write string to file, with line terminator, buffered  */
  382.  
  383. zsoutl(n,s) int n; char *s; {
  384.     /* if (chkfn(n) < 1) return(-1); */
  385.     fputs(s,fp[n]);
  386.     fputs("\n",fp[n]);
  387.     return(0);
  388. }
  389.  
  390. /*  Z S O U T X  --  Write x characters to file, unbuffered.  */
  391.  
  392. zsoutx(n,s,x) int n, x; char *s; {
  393.     /* if (chkfn(n) < 1) return(-1); */
  394.     return(write(fileno(fp[n]),s,(unsigned int)x));
  395. }
  396.  
  397.  
  398. /*  Z C H O U T  --  Add a character to the given file.  */
  399.  
  400. /*  Should return 0 or greater on success, -1 on failure (e.g. disk full)  */
  401.  
  402. int
  403. #ifdef CK_ANSIC
  404. zchout(register int n, char c)
  405. #else
  406. zchout(n,c) register int n; char c;
  407. #endif /* CK_ANSIC */
  408. /* zchout */ {
  409.     /* if (chkfn(n) < 1) return(-1); */
  410.     if (n == ZSFILE)
  411.         return(write(fileno(fp[n]),&c,1));/*Use unbuffered for session log*/
  412.     else {    /* Buffered for everything else */
  413.         if (putc(c,fp[n]) == EOF) /* If true, maybe there was an error */
  414.         {
  415.             return(ferror(fp[n])); /* Check to make sure */
  416.         }
  417.         else return(0);   /* There was no error. */
  418.     }
  419. }
  420.  
  421. /* (PWP) buffered character output routine to speed up file IO */
  422. zoutdump()
  423. {
  424.     if (zoutcnt == 0) return (0); /* nothing to output */
  425.     if (zoutcnt < 0) return (-1); /* unexpected */
  426.  
  427.     zoutptr = zoutbuffer;      /* Reset buffer pointer in all cases */
  428.     if (fwrite ((char *)zoutbuffer, 1, zoutcnt, fp[ZOFILE]))
  429.     {
  430.         fflush(fp[ZOFILE]);
  431.         zoutcnt = 0;            /* reset output buffer */
  432.         zoutptr = zoutbuffer;
  433.         return(0);              /* things worked OK */
  434.     }
  435.     zoutcnt = 0;            /* reset output buffer */
  436.     return(ferror(fp[ZOFILE])?-1:0); /* Check to make sure */
  437. }
  438.  
  439. /*  C H K F N  --  Internal function to verify file number is ok  */
  440.  
  441. /*
  442.  Returns:
  443.   -1: File number n is out of range
  444.    0: n is in range, but file is not open
  445.    1: n in range and file is open
  446. */
  447. chkfn(n) int n; {
  448.     switch (n) {
  449.         case ZCTERM:
  450.         case ZSTDIO:
  451.         case ZIFILE:
  452.         case ZOFILE:
  453.         case ZDFILE:
  454.         case ZTFILE:
  455.         case ZPFILE:
  456.         case ZSFILE:
  457.         case ZSYSFN:
  458.         case ZRFILE:
  459.         case ZWFILE: break;
  460.  
  461.         default:
  462.             debug(F101,"chkfn: file number out of range","",n);
  463.             fprintf(stderr,"?File number out of range - %d\n",n);
  464.             return(-1);
  465.     }
  466.     return( (fp[n] == NULL) ? 0 : 1 );
  467. }
  468.  
  469. /*  Z C H K I  --  Check if input file exists and is readable  */
  470.  
  471. /*
  472.   Returns:
  473.    >= 0 if the file can be read (returns the size).
  474.      -1 if file doesn't exist or can't be accessed,
  475.      -2 if file exists but is not readable (e.g. a directory file).
  476.      -3 if file exists but protected against read access.
  477. */
  478. long
  479. zchki(name) char *name; {
  480.     int x;
  481.  
  482.     if (access(name,0) < 0) {
  483.         if(access(name,S_IFDIR)>=0) {
  484.             debug(F111,"zchki skipping:",name,errno);
  485.             return(-2);
  486.         }
  487.         debug(F111,"zchki can't access",name,errno);
  488.         return(-1);
  489.     }
  490.  
  491.     if ((x = access(name,S_IREAD)) < 0) {  /* Is the file accessible? */
  492.         debug(F111," access failed:",name,x); /* No */
  493.         return(-3);
  494.     }
  495.     debug(F110," access ok:",name,0);
  496.     if((x = open(name,S_IREAD)) < 0) {
  497.         debug(F111,"zchki can't open:",name,errno);
  498.         return(-2);
  499.     }
  500.     debug(F111,"zchki stat ok:",name,x);
  501.     cur_in_size = _gs_size(x);                /* remember size */
  502.     _gs_gfd(x,&cur_in_fd,sizeof(cur_in_fd));        /* remember filedespr. */
  503.     close(x);
  504.     debug(F111," access ok:",name,cur_in_size);
  505.     return( (cur_in_size > -1) ? cur_in_size : 0 );
  506. }
  507.  
  508. /*  Z C H K O  --  Check if output file can be created  */
  509.  
  510. /*
  511.  Returns -1 if write permission for the file would be denied, 0 otherwise.
  512. */
  513. zchko(name) char *name; {
  514.     int i, x;
  515.     char s[50], *sp;
  516.  
  517.     if(access(name,S_IFDIR)>=0) return -1;      /* it's a directory */
  518.     sp = s;    /* Make a copy, get length */
  519.     x = 0;
  520.     while ((*sp++ = *name++) != '\0')
  521.         x++;
  522.     if (x == 0) return(-1);             /* If no filename, fail. */
  523.  
  524.     debug(F101," length","",x);
  525.     for (i = x; i > 0; i--) {           /* Strip filename. */
  526.         if(!isalnum(s[i-1])) {
  527.             switch(s[i-1]) {
  528.                 case '.':
  529.                 case '$':
  530.                 case '_': continue;
  531.                 case '/': break;
  532.                 default: return -1;     /* bad character */
  533.             }
  534.             break;
  535.         }
  536.     }
  537.     debug(F101," i","",i);
  538.     if (i == 0)                    /* If no path, use current directory */
  539.         strcpy(s,".");
  540.     else {                         /* Otherwise, use given one. */
  541.         if(i==x) return -1;        /* no filename! */
  542.         s[--i] = '\0';
  543.     }
  544.     x = access(s,S_IFDIR|S_IWRITE);     /* Check access of path. */
  545.     if (x < 0) {
  546.     fprintf(stderr,"access failed %s   errno:%d\n",s,errno);
  547.         debug(F111,"zchko access failed:",s,errno);
  548.         return(-1);
  549.     } else {
  550.         debug(F111,"zchko access ok:",s,x);
  551.         return(0);
  552.     }
  553. }
  554.  
  555. /*  Z C H K S P A  --  Check if there is enough space to store the file  */
  556.  
  557. /*
  558.  Call with file specification f, size n in bytes.
  559.  Returns -1 on error, 0 if not enough space, 1 if enough space.
  560. */
  561. zchkspa(f,n) char *f; long n; {         /* Just dummy for now. */
  562.     return(1);                          /* Always say OK. */
  563. }
  564.  
  565.  
  566. /*  Z D E L E T  --  Delete the named file.  */
  567.  
  568. zdelet(name) char *name; {
  569.     return(unlink(name));
  570. }
  571.  
  572.  
  573. /*  Z R T O L  --  Convert remote filename into local form  */
  574.  
  575. /*  For OS9, this means changing uppercase letters to lowercase
  576.     and making shure only a-z,A-Z,0-9,$,_,. are used */
  577. VOID
  578. zrtol(name,name2) char *name, *name2; {
  579.     for ( ; *name != '\0'; name++) {
  580.         if (isupper(*name))
  581.           *name2++ = tolower(*name);
  582.         else if (islower(*name) || isdigit(*name)
  583.                 || *name == '$' || *name == '.' || *name == '_')
  584.           *name2++ = *name;
  585.         else
  586.           *name2++ = '_'; /* otherwise use '_' */
  587.     }
  588.     *name2 = '\0';
  589.     debug(F110,"zrtol:",name2,0);
  590. }
  591.  
  592.  
  593. /*  Z L T O R  --  Local TO Remote */
  594.  
  595. /*  Convert filename from local format to common (remote) form.  */
  596. VOID
  597. zltor(name,name2) char *name, *name2; {
  598.     char work[100], *cp, *pp;
  599.     int dc = 0;
  600.  
  601.     debug(F110,"zltor",name,0);
  602.     pp = work;
  603.     for (cp = name; *cp != '\0'; cp++) { /* strip path name */
  604.         if (*cp == '/') {
  605.             dc = 0;
  606.             pp = work;
  607.         }
  608.         else if (islower(*cp)) *pp++ = toupper(*cp); /* Uppercase letters */
  609.         else if (*cp == '$') *pp++ = 'X';    /* Change '$' to 'X' */
  610.         else if ((*cp == '.') && (++dc > 1)) *pp++ = 'X'; /* & extra dots */
  611.         else *pp++ = *cp;
  612.     }
  613.     *pp = '\0';    /* Tie it off. */
  614.     cp = name2;    /* If nothing before dot, */
  615.     if (*work == '.') *cp++ = 'X'; /* insert 'X' */
  616.     strcpy(cp,work);
  617.     debug(F110," name2",name2,0);
  618. }
  619.  
  620.  
  621. /*  Z C H D I R  --  Change directory  */
  622.  
  623. zchdir(dirnam) char *dirnam; {
  624.     char *hd;
  625.     if (*dirnam == '\0') hd = getenv("HOME");
  626.     else hd = dirnam;
  627.     return((chdir(hd) == 0) ? 1 : 0);
  628. }
  629.  
  630.  
  631. /*  Z H O M E  --  Return pointer to user's home directory  */
  632.  
  633. char *
  634. zhome() {
  635.     return(getenv("HOME"));
  636. }
  637.  
  638. /*  Z X C M D -- Run a system command so its output can be read like a file */
  639.  
  640. zxcmd(filnum,comand) int filnum;char *comand; {
  641. FILE *pipeopen(),*filedesc;
  642.  
  643.     if (chkfn(filnum) < 0) return(-1); /* Need a valid kermit file number */
  644.     if (filnum == ZSTDIO || filnum == ZCTERM) return(0);
  645.  
  646.     if (filnum == ZIFILE || filnum == ZRFILE) /* kermit wants to read */
  647.     {
  648.       debug(F111," zxcmd read:",comand,filnum);
  649.       if ((filedesc = pipeopen(comand,"r")) != (FILE *)NULL)
  650.       {
  651.         fp[filnum] = filedesc;
  652.         fp[ZSYSFN] = fp[filnum];    /* Remember. */
  653.         zincnt = 0;
  654.         zinptr = zinbuffer;
  655.       }
  656.       else
  657.         return(0);
  658.     }
  659.     else
  660.     {
  661.       debug(F111," zxcmd write:",comand,filnum);
  662.       if ((filedesc = pipeopen(comand,"w")) != (FILE *)NULL)
  663.       {
  664.         fp[filnum] = filedesc;
  665.         fp[ZSYSFN] = fp[filnum];    /* Remember. */
  666.         zoutcnt = 0;
  667.         zoutptr = zoutbuffer;
  668.       }
  669.       else
  670.         return(0);
  671.     }
  672.     return(1); /* return success if we ever get here */
  673. }
  674.  
  675. /* KILL_TREE recursively kill all processes of a forked tree */
  676. static void kill_tree(root) unsigned int root;
  677. {
  678. struct {
  679.     unsigned short
  680.         _id,                /* process id */
  681.         _pid,                /* parent's id */
  682.         _sid,                /* sibling's id */
  683.         _cid;                /* child's id */
  684.         } prdesc; /* NOT whole process descriptor! too much stack needed */
  685. unsigned int child;
  686.  
  687.   if(_get_process_desc(root,sizeof(prdesc),&prdesc)==(int)-1) return;
  688.   if ((child = prdesc._cid) != 0) kill_tree(child); /* kill child's tree */
  689.   if ((child = prdesc._sid) != 0) kill_tree(child); /* kill siblings tree */
  690.   kill(root,SIGKILL);
  691. }
  692.  
  693. /* Z C L O S F - kill the child(action may have aborted and close the pipe.*/
  694.  
  695. zclosf(filnum) int filnum;{
  696.     int wstat;
  697.     debug(F101," zclosf filnum:","",filnum);
  698.     fclose(fp[filnum]);
  699.     fp[filnum] = fp[ZSYSFN] = NULL;
  700.     if (pipe_pid == 0) return(-1);
  701.     kill_tree(pipe_pid); /*kill all lower processes in case things have
  702.                             been aborted */
  703.     debug(F101," zclosf killed:","",pipe_pid);
  704.     while ((wstat = wait((unsigned int *)0)) != pipe_pid && wstat != -1) ;
  705.     pipe_pid = 0;
  706.     return(1);
  707. }
  708.  
  709. /*  Z X P A N D  --  Expand a wildcard string into an array of strings  */
  710. /*
  711.   Returns the number of files that match fn1, with data structures set up
  712.   so that first file (if any) will be returned by the next znext() call.
  713. */
  714. zxpand(fn) char *fn; {
  715.     fcount = fgen(fn,mtchs,MAXWLD); /* Look up the file. */
  716.     if (fcount > 0) {
  717.         mtchptr = mtchs;  /* Save pointer for next. */
  718.     }
  719.     debug(F111,"zxpand",mtchs[0],fcount);
  720.     return(fcount);
  721. }
  722.  
  723.  
  724. /*  Z N E X T  --  Get name of next file from list created by zxpand(). */
  725. /*
  726.  Returns >0 if there's another file,with its name copied into the arg string
  727.  or 0 if no more files in list.
  728. */
  729. znext(fn) char *fn; {
  730.     if (fcount-- > 0) strcpy(fn,*mtchptr++);
  731.     else *fn = '\0';
  732.     debug(F111,"znext",fn,fcount+1);
  733.     return(fcount+1);
  734. }
  735.  
  736.  
  737. /*  Z N E W N  --  Make a new name for the given file  */
  738. VOID
  739. znewn(fn,s) char *fn, **s; {
  740.     static char buf[256];
  741.     char *bp, *xp;
  742.     int len = 0, n = 0, d = 0, t, i, power = 1;
  743. #ifdef MAXNAMLEN
  744.     int max = MAXNAMLEN;
  745. #else
  746.     int max = 14;
  747. #endif
  748.     bp = buf;
  749.     while (*fn) {   /* Copy name into buf */
  750.         *bp++ = *fn++;
  751.         len++;
  752.     }
  753.     if (len > max-2) {    /* Don't let it get too long */
  754.         bp = buf + max-2;
  755.         len = max - 2;
  756.     }
  757.  
  758.     for (i = 1; i < 4; i++) {  /* Try up to 999 times */
  759.         power *= 10;
  760.         *bp++ = '*';   /* Put a star on the end */
  761.         *bp-- = '\0';
  762.  
  763.         n = zxpand(buf);  /* Expand the resulting wild name */
  764.  
  765.         while (n-- > 0) {  /* Find any existing name_d files */
  766.             xp = *mtchptr++;
  767.             xp += len;
  768.             if (*xp == '_') {
  769.                 t = atoi(xp+1);
  770.                 if (t > d) d = t; /* Get maximum d */
  771.             }
  772.         }
  773.         if (d < power-1) {
  774.             sprintf(bp,"_%d",d+1); /* Make name_(d+1) */
  775.             *s = buf;
  776.             return;
  777.         }
  778.         bp--; len--;
  779.     }
  780. /* If we ever get here, we'll overwrite the xxx~100 file... */
  781. }
  782.  
  783. /*  Z S A T T R */
  784. /*
  785.  Fills in a Kermit file attribute structure for the file which is to be sent.
  786.  Returns 0 on success with the structure filled in, or -1 on failure.
  787.  If any string member is null, then it should be ignored.
  788.  If any numeric member is -1, then it should be ignored.
  789. */
  790. zsattr(xx) struct zattr *xx; {
  791.     int k;
  792.     static char protection[2];
  793.     static char * get_gmtime();
  794.  
  795.     k = cur_in_size % 1024L;                  /* File length in K */
  796.     if (k != 0L) k = 1L;
  797.     xx->lengthk = (cur_in_size / 1024L) + k;
  798. /*  if ((cur_in_fd.fd_att & S_IEXEC) || (cur_in_fd.fd_att & S_IOEXEC))
  799.     {
  800.       xx->type.len = 1;
  801.       xx->type.val = "B";
  802.     }
  803.     else
  804.     {
  805.       xx->type.len = 0;
  806.       xx->type.val = "";
  807.     }
  808. */  xx->type.len = 0;               /* better let the user decide */
  809.     xx->type.val = "";
  810.     xx->date.val = get_gmtime(&cur_in_fd); /* get UCT time, if possible */
  811.     xx->date.len = strlen(xx->date.val);
  812.     debug(F111,"zsattr date",xx->date.val,xx->date.len);
  813.     xx->creator.len = 0;                /* File creator */
  814.     xx->creator.val = "";
  815.     xx->account.len = 0;                /* File account */
  816.     xx->account.val = "";
  817.     xx->area.len = 0;                   /* File area */
  818.     xx->area.val = "";
  819.     xx->passwd.len = 0;                 /* Area password */
  820.     xx->passwd.val = "";
  821.     xx->blksize = -1L;                  /* File blocksize */
  822.     xx->access.len = 0;                 /* File access */
  823.     xx->access.val = "";
  824.     xx->encoding.len = 0;               /* Transfer syntax */
  825.     xx->encoding.val = 0;
  826.     xx->disp.len = 0;                   /* Disposition upon arrival */
  827.     xx->disp.val = "";
  828.  
  829.     protection[0] = cur_in_fd.fd_att & 0x7f;
  830.     protection[1] = 0;
  831.     xx->lprotect.val = protection;
  832.     xx->lprotect.len = 1;
  833.     debug(F101,"zsattr lprotect","",xx->lprotect.val[0]);
  834.  
  835.     xx->gprotect.len = 0;               /* Generic protection */
  836.     xx->gprotect.val = "";
  837.     xx->systemid.len = 2;               /* System ID */
  838.     xx->systemid.val = "UD";
  839.     xx->recfm.len = 0;                  /* Record format */
  840.     xx->recfm.val = "";
  841.     xx->sysparam.len = 0;               /* System-dependent parameters */
  842.     xx->sysparam.val = "";
  843.     debug(F101,"zsattr size","",cur_in_size);
  844.     xx->length = cur_in_size;                 /* Length */
  845.     return(0);
  846. }
  847.  
  848. zmail(p,f) char *p; char *f; {
  849.     /* Send file f as mail to address p; no mail on OS-9 */
  850.     return(-1);
  851. }
  852.  
  853. zprint(p,f) char *p; char *f; {
  854.     /* Print file f with options p; no unique print device on OS-9 */
  855.     return(-1);
  856. }
  857.  
  858. /* Directory Functions for Unix, written by Jeff Damens, CUCCA, 1984. */
  859. /*
  860.  * The path structure is used to represent the name to match.
  861.  * Each slash-separated segment of the name is kept in one
  862.  * such structure, and they are linked together, to make
  863.  * traversing the name easier.
  864.  */
  865.  
  866. struct path {
  867.               char npart[MAXNAMLEN]; /* name part of path segment */
  868.               struct path *fwd;  /* forward ptr */
  869.             };
  870.  
  871. #define SSPACE 2000   /* size of string-generating buffer */
  872. static char sspace[SSPACE];          /* buffer to generate names in */
  873. static char *freeptr,**resptr;       /* copies of caller's arguments */
  874. static int remlen;                   /* remaining length in caller's array*/
  875. static int numfnd;                   /* number of matches found */
  876.  
  877. /*
  878.  * splitpath:
  879.  *  takes a string and splits the slash-separated portions into
  880.  *  a list of path structures.  Returns the head of the list.  The
  881.  *  structures are allocated by malloc, so they must be freed.
  882.  *  Splitpath is used internally by the filename generator.
  883.  *
  884.  * Input: A string.
  885.  * Returns: A linked list of the slash-separated segments of the input.
  886.  */
  887.  
  888. struct path *
  889. splitpath(p)
  890. char *p;
  891. {
  892.     struct path *head,*cur,*prv;
  893.     int i;
  894.     head = prv = NULL;
  895.     if (*p == '/') p++;            /* skip leading slash */
  896.     while (*p != '\0') {
  897.         cur = (struct path *) malloc(sizeof (struct path));
  898.         debug(F101,"splitpath malloc","",(int)cur);
  899.         if (cur == NULL) fatal("malloc fails in splitpath()");
  900.         cur -> fwd = NULL;
  901.         if (head == NULL) head = cur;
  902.         else prv -> fwd = cur;       /* link into chain */
  903.         prv = cur;
  904.         for (i=0; i < MAXNAMLEN && *p != '/' && *p != '\0'; i++)
  905.             cur -> npart[i] = *p++;
  906.         cur -> npart[i] = '\0';      /* end this segment */
  907.         if (i >= MAXNAMLEN) while (*p != '/' && *p != '\0') p++;
  908.         if (*p == '/') p++;
  909.     }
  910.     return(head);
  911. }
  912.  
  913. /*
  914.  * fgen:
  915.  *  This is the actual name generator.  It is passed a string,
  916.  *  possibly containing wildcards, and an array of character pointers.
  917.  *  It finds all the matching filenames and stores them into the array.
  918.  *  The returned strings are allocated from a static buffer local to
  919.  *  this module (so the caller doesn't have to worry about deallocating
  920.  *  them); this means that successive calls to fgen will wipe out
  921.  *  the results of previous calls.  This isn't a problem here
  922.  *  because we process one wildcard string at a time.
  923.  *
  924.  * Input: a wildcard string, an array to write names to, the
  925.  *        length of the array.
  926.  * Returns: the number of matches.  The array is filled with filenames
  927.  *          that matched the pattern.  If there wasn't enough room in the
  928.  *     array, -1 is returned.
  929.  * By: Jeff Damens, CUCCA, 1984.
  930.  */
  931.  
  932. fgen(pat,resarry,len)
  933. char *pat,*resarry[];
  934. int len;
  935. {
  936.         VOID traverse();
  937.     struct path *head;
  938.     char scratch[100+MAXNAMLEN],*sptr;
  939.     head = splitpath(pat);
  940.     if (*pat == '/') {
  941.         scratch[0] = '/';
  942.         sptr = scratch+1;
  943.         *sptr = '\0';
  944.     } else {
  945.         strcpy(scratch,"./");
  946.         sptr = scratch+2;
  947.     }     /* init buffer correctly */
  948.     numfnd = 0;                            /* none found yet */
  949.     freeptr = sspace;   /* this is where matches are copied */
  950.     resptr = resarry;   /* static copies of these so*/
  951.     remlen = len;    /* recursive calls can alter them */
  952.     traverse(head,scratch,sptr);  /* go walk the directory tree */
  953.     while (head != NULL) {
  954.         struct path *next = head -> fwd;
  955.         free((char *)head);
  956.         head = next;
  957.     }
  958.     return(numfnd);   /* and return the number of matches */
  959. }
  960.  
  961. /* traverse:
  962.  *  Walks the directory tree looking for matches to its arguments.
  963.  *  The algorithm is, briefly:
  964.  *   If the current pattern segment contains no wildcards, that
  965.  *   segment is added to what we already have.  If the name so far
  966.  *   exists, we call ourselves recursively with the next segment
  967.  *   in the pattern string; otherwise, we just return.
  968.  *
  969.  *   If the current pattern segment contains wildcards, we open the name
  970.  *   we've accumulated so far (assuming it is really a directory), then read
  971.  *   each filename in it, and, if it matches the wildcard pattern segment,add
  972.  *   that filename to what we have so far and call ourselves recursively on
  973.  *   the next segment.
  974.  *
  975.  *   Finally, when no more pattern segments remain, we add what's accumulated
  976.  *   so far to the result array and increment the number of matches.
  977.  *
  978.  * Input: a pattern path list (as generated by splitpath), a string
  979.  *   pointer that points to what we've traversed so far (this
  980.  *   can be initialized to "/" to start the search at the root
  981.  *   directory, or to "./" to start the search at the current
  982.  *   directory), and a string pointer to the end of the string
  983.  *   in the previous argument.
  984.  * Returns: nothing.
  985.  */
  986. VOID
  987. traverse(pl,sofar,endcur)
  988. struct path *pl;
  989. register char *sofar,*endcur;
  990. {
  991.     DIR *fd, *opendir();
  992.         VOID addresult();
  993.     struct direct *dirbuf;
  994.     debug(F110,"traverse ",sofar,0);
  995.     if (pl == NULL) {
  996.         *--endcur = '\0';               /* end string, overwrite trailing / */
  997.         addresult(sofar);
  998.         return;
  999.     }
  1000.     if (!iswild(pl -> npart)) {
  1001.         strcpy(endcur,pl -> npart);
  1002.         endcur += strlen(endcur);
  1003.         if (access(sofar,S_IFDIR) == 0) { /* if current piece exists & dir */
  1004.             *endcur++ = '/';            /* add slash to end */
  1005.             *endcur = '\0';             /* and end the string */
  1006.             traverse(pl -> fwd,sofar,endcur);
  1007.         } else if(access(sofar,0) == 0 && pl->fwd==NULL) {
  1008.             addresult(sofar);
  1009.         }
  1010.         return;
  1011.     }
  1012.  
  1013. /* segment contains wildcards, have to search directory */
  1014.     *--endcur = '\0';                   /* end current string */
  1015.     if (access(sofar,S_IFDIR) < 0) {
  1016.         debug(F111,"traverse can't access directory",sofar,errno);
  1017.         return; /* doesn't exist, forget it */
  1018.     }
  1019.     if ((fd = opendir(sofar)) == NULL) {
  1020.         debug(F111,"traverse can't open directory",sofar,errno);
  1021.         return; /* can't open, forget it */
  1022.     }
  1023.     *endcur++ = '/';
  1024.     while (dirbuf = readdir(fd)) {
  1025.         if (dirbuf->d_addr != 0) {
  1026.             strncpy(endcur,dirbuf->d_name,MAXNAMLEN); /* Get a null 
  1027.                                                          terminated copy!!! */
  1028.             if(match(pl -> npart,endcur)) {
  1029.                 char *eos;
  1030.                 eos = endcur + strlen(endcur);
  1031.                 *eos++ = '/';                   /* end this segment */
  1032.                 *eos = '\0';
  1033.                 traverse(pl -> fwd,sofar,eos);
  1034.             }
  1035.         }
  1036.     }
  1037.     closedir(fd);
  1038. }
  1039.  
  1040. /*
  1041.  * addresult:
  1042.  *  Adds a result string to the result array.  Increments the number
  1043.  *  of matches found, copies the found string into our string
  1044.  *  buffer, and puts a pointer to the buffer into the caller's result
  1045.  *  array.  Our free buffer pointer is updated.  If there is no
  1046.  *  more room in the caller's array, the number of matches is set to -1.
  1047.  * Input: a result string.
  1048.  * Returns: nothing.
  1049.  */
  1050.  
  1051. VOID
  1052. addresult(str)
  1053. register char *str;
  1054. {
  1055.     register int l;
  1056.     if (strncmp(str,"./",2) == 0) str += 2;
  1057.     if (--remlen < 0) {
  1058.         numfnd = -1;
  1059.         return;
  1060.     }
  1061.     l = strlen(str) + 1;   /* size this will take up */
  1062.     if ((freeptr + l) > &sspace[SSPACE]) {
  1063.         numfnd = -1;   /* do not record if not enough space */
  1064.         return;
  1065.     }
  1066.     strcpy(freeptr,str);
  1067.     *resptr++ = freeptr;
  1068.     freeptr += l;
  1069.     numfnd++;
  1070. }
  1071.  
  1072. iswild(str)
  1073. register char *str;
  1074. {
  1075.     register char c;
  1076.     while ((c = *str++) != '\0')
  1077.         if (c == '*' || c == '?') return(1);
  1078.     return(0);
  1079. }
  1080.  
  1081. /*
  1082.  * match:
  1083.  *  pattern matcher.  Takes a string and a pattern possibly containing
  1084.  *  the wildcard characters '*' and '?'.  Returns true if the pattern
  1085.  *  matches the string, false otherwise.
  1086.  * Input: a string and a wildcard pattern.
  1087.  * Returns: 1 if match, 0 if no match.
  1088.  */
  1089.  
  1090. match(pattern,string) char *pattern,*string; {
  1091.     int i;
  1092.     i = _cmpnam(string,pattern,strlen(pattern))==0;
  1093.     debug(F111,"Match ",string,i);
  1094.     return i;
  1095. }
  1096.  
  1097. /* emulate unix perror function */
  1098.  
  1099. perror(string)
  1100. char *string;
  1101. {
  1102.     extern int errno;
  1103.     fprintf(stderr,"%s ERRNO: %d\n",string,errno);
  1104. }
  1105.  
  1106. #ifdef DTILDE
  1107. char *
  1108. tilde_expand(dirname)
  1109. register char *dirname;
  1110. {
  1111.     static char *home = NULL;
  1112.     static char temp[MAXNAMLEN];
  1113.  
  1114.     debug(F111,"tilde_expand dirname", dirname, dirname[0]);
  1115.     if(*dirname++ != '~' || (*dirname != '\0' && *dirname != '/'))
  1116.                 return --dirname;
  1117.     if(home == NULL && (home = getenv("HOME")) == NULL) return --dirname;
  1118.     if(*dirname == '\0') return home;
  1119.     strcpy(temp, home);
  1120.     strcat(temp, dirname);
  1121.     return temp;
  1122. }
  1123. #endif
  1124.  
  1125. /* Z S T I M E  --  Set creation date for incoming file */
  1126. /*
  1127.  Call with:
  1128.  f  = pointer to name of existing file.
  1129.  yy = pointer to a Kermit file attribute structure in which yy->date.val
  1130.       is a date of the form [yy]yymmdd[ hh:mm[:ss]] e.g. 19900208 13:00:00.
  1131.  x  = is a function code: 0 means to set the file's creation date as given.
  1132.       1 means compare the given date with the file creation date.
  1133.  Returns:
  1134.  -1 on any kind of error.
  1135.   0 if x is 0 and the file date was set successfully.
  1136.   0 if x is 1 and date from attribute structure > file  creation date.
  1137.   1 if x is 1 and date from attribute structure <= file creation    date.
  1138. */
  1139.  
  1140. zstime(f,yy,x) char *f; register struct zattr *yy; int x;
  1141. {
  1142. extern int errno;
  1143. int r = -1;                             /* return code */
  1144. int path;
  1145. register char *point;
  1146. register char save;
  1147. char year,month,day,hour,minute,second;
  1148. struct fildes buffer;
  1149. unsigned char long_year=0,hour_min=0,err=0;
  1150. time_t mktime(),file_date;
  1151. static VOID convert_to_local_time();
  1152. struct tm tp;
  1153.     debug(F110,"zstime",f,0);
  1154.  
  1155.     switch (yy->date.len)
  1156.     {
  1157.     case 0:
  1158.         err = 1;
  1159.         break;
  1160.     case 6:   /* yymmdd */
  1161.         break;
  1162.     case 8:   /* yyyymmdd */
  1163.         long_year = 1;
  1164.         break;
  1165.     case 12:  /* yymmdd hh:mm */
  1166.         hour_min = 1;
  1167.         break;
  1168.     case 14:  /* yyyymmdd hh:mm */
  1169.         long_year = 1;
  1170.         hour_min = 1;
  1171.         break;
  1172.     case 15:  /* yymmdd hh:mm:ss */
  1173.         hour_min = 1;
  1174.         break;
  1175.     case 17:  /* yyyymmdd hh:mm::ss */
  1176.         long_year = 1;
  1177.         hour_min = 1;
  1178.         break;
  1179.     default:
  1180.         err = 1;
  1181.         break;
  1182.     }
  1183.     if (err)
  1184.     {
  1185.         debug(F111,"Bad creation date ",yy->date.val,yy->date.len);
  1186.         return(-1);
  1187.     }
  1188.  
  1189.     point = yy->date.val;
  1190.     if (long_year)
  1191.     {
  1192.       save = *(point+4);
  1193.       *(point+4) = '\0';
  1194.       year = atoi(point);
  1195.       *(point+4) = save;
  1196.       point += 4;
  1197.       year -= 1900; /* OS-9 only has year since 1900 */
  1198.     }
  1199.     else
  1200.     {
  1201.       save = *(point+2);
  1202.       *(point+2) = '\0';
  1203.       year = atoi(point);
  1204.       point += 2; /* don't add 1900: OS-9 only has year since 1900 anyway */
  1205.     }
  1206.  
  1207.     save = *(point+2);
  1208.     *(point+2) = '\0';
  1209.     month = atoi(point);
  1210.     *(point+2) = save;
  1211.  
  1212.     point += 2;
  1213.     save = *(point+2);
  1214.     *(point+2) = '\0';
  1215.     day = atoi(point);
  1216.     *(point+2) = save;
  1217.  
  1218.     if (hour_min)
  1219.     {
  1220.         point += 3; /* skip the blank */
  1221.         save = *(point+2);
  1222.         *(point+2) = '\0';
  1223.         hour = atoi(point);
  1224.         *(point+2) = save;
  1225.  
  1226.         point += 3; /* skip the : */
  1227.         save = *(point+2);
  1228.         *(point+2) = '\0';
  1229.         minute = atoi(point);
  1230.         *(point+2) = save;
  1231.  
  1232.         second = 0; /* no OS-9 seconds */
  1233.     }
  1234.     else /* no hours and minutes given */
  1235.     {
  1236.         hour = minute = second = 0;
  1237.     }
  1238.     err = 0;
  1239.     if  (year   >99) err = 1;
  1240.     if ((month  >12) || (month  < 1)) err = 1;
  1241.     if ((day    >31) || (day    < 1)) err = 1;
  1242.     if  (hour   >23) err = 1;
  1243.     if  (minute >59) err = 1;
  1244.  
  1245.     if (err)
  1246.     {
  1247.         debug(F111,"Bad creation date ",yy->date.val,yy->date.len);
  1248.         return(-1);
  1249.     }
  1250.  
  1251.     convert_to_local_time(&year,&month,&day,&hour,&minute,&second);
  1252.  
  1253.     if ((path = open(f,0)) == -1) /* mode 0 is sufficient for _gs_gfd */
  1254.     {
  1255.         debug(F110,"Can't open file to get fdesc:",f,0);
  1256.         return(r);
  1257.     }
  1258.     if (_gs_gfd(path,&buffer,sizeof(buffer)) == -1)
  1259.     {
  1260.         debug(F111,"Can't get descriptor for file:",f,errno);
  1261.         close(path);
  1262.         return(r);
  1263.     }
  1264.     close(path);
  1265.     switch (x)       /* Execute desired function */
  1266.     {
  1267.         case 0:      /* Set the creation and modification date of the file */
  1268.             buffer.fd_date[0] = year;
  1269.             buffer.fd_date[1] = month;
  1270.             buffer.fd_date[2] = day;
  1271.             buffer.fd_date[3] = hour;
  1272.             buffer.fd_date[4] = minute;
  1273.             buffer.fd_dcr[0] = year;
  1274.             buffer.fd_dcr[1] = month;
  1275.             buffer.fd_dcr[2] = day;
  1276.             if ((path = open(f,S_IWRITE)) == -1) /* _ss_pfd needs writing */
  1277.             {
  1278.                 debug(F110,"Can't open file for write:",f,0);
  1279.                 return(r);
  1280.             }
  1281.             if (_ss_pfd(path,&buffer) == -1)
  1282.             {
  1283.               debug(F111,"Can't update descriptor for file:",f,errno);
  1284.             }
  1285.             else
  1286.             {
  1287.               debug(F110,"Creat. and mod. time is set for file: ",f,0);
  1288.               r = 0;
  1289.             }
  1290.             close(path);
  1291.             break;
  1292.     case 1:             /* Compare the dates */
  1293.             tp.tm_sec  = 0;
  1294.             tp.tm_min  = buffer.fd_date[4];
  1295.             tp.tm_hour = buffer.fd_date[3];
  1296.             tp.tm_mday = buffer.fd_date[2];
  1297.             tp.tm_mon  = buffer.fd_date[1]-1;
  1298.             tp.tm_year = buffer.fd_date[0];
  1299.  
  1300.             file_date = mktime(&tp);
  1301.  
  1302.             tp.tm_min  = minute;
  1303.             tp.tm_hour = hour;
  1304.             tp.tm_mday = day;
  1305.             tp.tm_mon  = month-1;
  1306.             tp.tm_year = year;
  1307.  
  1308.             if (mktime(&tp) > file_date) r=0;
  1309.             else r=1;
  1310.             break;
  1311.     default:                            /* Error */
  1312.             break;
  1313.     }
  1314.     close(path);
  1315.     return(r);
  1316. }
  1317.  
  1318. /*  Z R E N A M E  --  Rename a file  */
  1319.  
  1320. /*  Call with old and new names */
  1321. /*  Returns 0 on success, -1 on failure. */
  1322.  
  1323. zrename(old,new) register char *old, *new;
  1324. {
  1325. char buffer[256];
  1326.         sprintf(buffer,"rename %s %s",old,new);
  1327.         if (zsyscmd(buffer) != 0)
  1328.         {
  1329.           debug(F111,"Can't rename:",old,errno);
  1330.           return(-1);
  1331.         }
  1332.         return(0);
  1333. }
  1334.  
  1335. /*
  1336.   Functions for executing system commands.
  1337.   zsyscmd() executes the system command in the normal, default way for
  1338.   the system.  In UNIX, it does what system() does.  Thus, its results
  1339.   are always predictable.
  1340.   zshcmd() executes the command using the user's preferred shell.
  1341. */
  1342. zsyscmd(s) char *s;
  1343. {
  1344. unsigned int status;
  1345. extern int os9forkc();
  1346. extern char **environ;
  1347. char *(argblk[3]);
  1348. int pid,wstat;
  1349.   debug(F110,"zsyscmd:try:",s,0);
  1350.                  /* chaining (shell ex command) would save a process but */
  1351.   argblk[2] = 0; /* f$chain does not use PATH */
  1352.   argblk[1] = s;
  1353.   argblk[0] = "shell";
  1354.   if ((pid = os9exec(os9forkc,argblk[0],argblk,environ,0,0,3)) > 0)
  1355.   {
  1356.     while ((wstat = wait(&status)) != pid && wstat != -1) ;
  1357.     if (status != 0)
  1358.     {
  1359.       debug(F111,"zsyscmd:can't execute:",s,status);
  1360. /*    return(-1); */
  1361.     }
  1362.   }
  1363.   else
  1364.   {
  1365.     debug(F111,"zsyscmd:can't fork:",s,errno);
  1366. /*  return(-1); */
  1367.   }
  1368.   debug(F110,"zsyscmd: success:",s,0);
  1369.   return(0);
  1370. }
  1371.  
  1372. zshcmd(s) register char *s;
  1373. {
  1374. unsigned int status;
  1375. extern int os9forkc();
  1376. extern char **environ;
  1377. char *(argblk[3]);
  1378. int pid,wstat;
  1379.   debug(F110,"zshcmd:try:",s,0);
  1380.                  /* chaining (shell ex command) would save a process but */
  1381.   argblk[2] = 0; /* f$chain does not use PATH */
  1382.   argblk[1] = s;
  1383.   argblk[0] = getenv("SHELL");
  1384.   if (argblk[0] == (char *)0) argblk[0] = "shell";
  1385.   if ((pid = os9exec(os9forkc,argblk[0],argblk,environ,0,0,3)) > 0)
  1386.   {
  1387.     while ((wstat = wait(&status)) != pid && wstat != -1) ;
  1388.     if (status != 0)
  1389.     {
  1390.       debug(F111,"zshcmd:can't execute:",s,status);
  1391. /*    return(-1); */
  1392.     }
  1393.   }
  1394.   else
  1395.   {
  1396.     debug(F111,"zshcmd:can't fork:",s,errno);
  1397. /*  return(-1); */
  1398.   }
  1399.   return(0);
  1400. }
  1401.  
  1402. /*  Z S T R I P  --  Strip device & directory name from file specification */
  1403.  
  1404. /*  Strip pathname from filename "name", return pointer to result in name2 */
  1405.  
  1406. char work[100]; /* buffer for use by zstrip and zltor */
  1407.  
  1408. VOID
  1409. zstrip(name,name2) char *name, **name2; {
  1410.     char *cp, *pp;
  1411.     debug(F110,"zstrip before",name,0);
  1412.     pp = work;
  1413. #ifdef DTILDE
  1414.     if (*name == '~') name++;
  1415. #endif
  1416.     for (cp = name; *cp != '\0'; cp++) {
  1417.         if (*cp == '/')
  1418.           pp = work;
  1419.         else
  1420.           *pp++ = *cp;
  1421.     }
  1422.     *pp = '\0';                         /* Terminate the string */
  1423.     *name2 = work;
  1424.     debug(F110,"zstrip after",*name2,0);
  1425. }
  1426.  
  1427. /*  Z S I N L  --  Read a line from a file  */
  1428.  
  1429. /*
  1430.   Writes the line into the address provided by the caller.
  1431.   n is the Kermit "channel number".
  1432.   Writing terminates when newline is encountered, newline is not copied.
  1433.   Writing also terminates upon EOF or if length x is exhausted.
  1434.   Returns 0 on success, -1 on EOF or error.
  1435. */
  1436. zsinl(n,s,x) int n, x; char *s; {
  1437.     int a, z = 0;
  1438.  
  1439.     if (chkfn(n) < 1) {                 /* Make sure file is open */
  1440.           return(-1);
  1441.     }
  1442.     a = -1;
  1443.     while (x--) {
  1444.       if (zchin(n,&a) < 0) {       /* Read a character from the file */
  1445.         z = -1;
  1446.         break;
  1447.       }
  1448.       if ( a == (char) NLCHAR) break; /* Single-character line terminator */
  1449.       *s = a;
  1450.       s++;
  1451.     }
  1452.     *s = '\0';
  1453.     return(z);
  1454. }
  1455.  
  1456. static char
  1457. *get_gmtime(file_desc) struct fildes *file_desc;
  1458. /* returns UCT/GMT yyyymmdd hh:mm:00 time out of the file descriptor
  1459.    if im possible to get GMT it takes the time from the file descriptor
  1460.    without converion */
  1461. {
  1462. static char datbuf[18]; /* must be static !!! */
  1463. struct tm *gmt,tp;
  1464. time_t local_file_date;
  1465. unsigned char we_know_gmt=0;
  1466.  
  1467.   while(1)
  1468.   {
  1469.     if (getenv("TZ") == (char *)NULL) /* if TZ not defined send modification
  1470.                                          date literally */
  1471.       break;
  1472.  
  1473.     tp.tm_sec  = 0;
  1474.     tp.tm_min  = file_desc->fd_date[4];
  1475.     tp.tm_hour = file_desc->fd_date[3];
  1476.     tp.tm_mday = file_desc->fd_date[2];
  1477.     tp.tm_mon  = file_desc->fd_date[1]-1;
  1478.     tp.tm_year = file_desc->fd_date[0];
  1479.     local_file_date = mktime(&tp);
  1480.  
  1481.     if (local_file_date == (time_t)-1) /* take time literally */
  1482.       break;
  1483.  
  1484.     gmt = gmtime(&local_file_date);
  1485.  
  1486.     if (gmt == (struct tm*)NULL) /* take time literally */
  1487.       break;
  1488.  
  1489.     we_know_gmt = 1;
  1490.     break;
  1491.   } /* end while (1) */
  1492.  
  1493.   if (we_know_gmt)
  1494.     sprintf(datbuf,"%4d%02d%02d %02d:%02d:%02d",
  1495.                    1900L+(unsigned int)gmt->tm_year,
  1496.                    gmt->tm_mon+1,gmt->tm_mday,gmt->tm_hour,gmt->tm_min,0);
  1497.   else
  1498.     sprintf(datbuf,"%4d%02d%02d %02d:%02d:%02d",
  1499.                         1900L+(unsigned int)file_desc->fd_date[0],
  1500.                         file_desc->fd_date[1],file_desc->fd_date[2],
  1501.                         file_desc->fd_date[3],file_desc->fd_date[4],0);
  1502.   return(datbuf);
  1503. }
  1504. static VOID
  1505. convert_to_local_time(year,month,day,hour,minute,second)
  1506. char *year,*month,*day,*hour,*minute,*second;
  1507. /* will convert to local time if timezone information is available assuming
  1508.    UCT/GMT time as input , otherwise just return.
  1509.    year must be since 1900 */
  1510. {
  1511. struct tm *tp;
  1512. time_t cal_date;
  1513. int time,date;
  1514. char *getenv();
  1515.  
  1516.   if (getenv("TZ") == (char *)NULL) return;
  1517.   date = ((1900+*year)<<16)+(*month<<8)+*day;
  1518.   time = (*hour<<16)+(*minute<<8)+*second;
  1519.   if (_julian(&time,&date) == -1) return;
  1520.   cal_date = (date-2440587)*86400+time; /* 2440587 = 1st of Jan 1970 */
  1521.  
  1522.   tp = localtime(&cal_date);
  1523.  
  1524.   if (tp == (struct tm*)NULL) return;
  1525.  
  1526.   *second = tp->tm_sec;
  1527.   *minute = tp->tm_min;
  1528.   *hour = tp->tm_hour;
  1529.   *day = tp->tm_mday;
  1530.   *month = tp->tm_mon+1;
  1531.   *year = tp->tm_year;
  1532.  
  1533. }
  1534. FILE *
  1535. pipeopen(command,access_type) char *command,*access_type;
  1536. {
  1537. extern int os9forkc();
  1538. extern char **environ;
  1539. int duped,dupederr,stdinout;
  1540. FILE *pipe;
  1541. char *argv[3];
  1542.  
  1543.     if (*access_type=='r') stdinout = 1; /* redirect stdout and stderr*/
  1544.     else if (*access_type=='w') stdinout = 0; /* redirect stdin */
  1545.     else return((FILE *)NULL);
  1546.  
  1547.     if((duped = dup(stdinout)) <= 0) return((FILE *)NULL);
  1548.     if(stdinout == 1)
  1549.     {
  1550.       if((dupederr = dup(2)) <= 0)
  1551.       {
  1552.         close(duped);
  1553.         return((FILE *)NULL);
  1554.       }
  1555.     }
  1556.     if((pipe = fopen("/pipe", "r+")) == NULL)
  1557.     {
  1558.         close(duped);
  1559.         if(stdinout == 1) close(dupederr);
  1560.         return((FILE *)NULL);
  1561.     }
  1562.     close(stdinout);
  1563.     dup(fileno(pipe));
  1564.     if (stdinout == 1) /* also dupe stderr */
  1565.     {
  1566.       close(2);
  1567.       dup(fileno(pipe));
  1568.     }
  1569.     argv[0] = "shell";
  1570.     argv[1] = command;
  1571.     argv[2] = (char *)NULL;
  1572.     if((pipe_pid = os9exec(os9forkc,argv[0],argv,environ,0,0,3)) < 0)
  1573.     {
  1574.         pipe_pid = 0;
  1575.         fclose(pipe);
  1576.  
  1577.         close(stdinout);
  1578.         dup(duped); /* restore old stdinout */
  1579.         close(duped);
  1580.         if(stdinout == 1) /* also restore old sterr */
  1581.         {
  1582.           close(2);
  1583.           dup(dupederr);
  1584.           close(dupederr);
  1585.         }
  1586.         return (FILE *)NULL;
  1587.     }
  1588.     debug(F101," pipeopen success id:","",pipe_pid);
  1589.     close(stdinout);
  1590.     dup(duped);
  1591.     close(duped);
  1592.     if(stdinout == 1)
  1593.     {
  1594.       close(2);
  1595.       dup(dupederr);
  1596.       close(dupederr);
  1597.     }
  1598.     return(pipe);
  1599. }
  1600.